#include"Stack.h"

#pragma pack(1)

// struct Stack
// {
// 	int* _a;
// 	int _top;
// 	int _capacity;
// };

// int StackTop()
// {
// 	//...
// }

// int main()
// {
// 	Stack st;

// 	st._a[st._top];

// 	return 0;
// }

// int main()
// {
// 	// 类 -> 对象   1->多
// 	// 对象的实例化
// 	// 对象的占用的大小，只考虑成员变量
// 	Stack st1;
// 	Stack st2;
// 	st1.Init();
// 	st2.Init();
// 	// st1._top++;
// 	// st2._top--;

// 	cout << sizeof(st1) << endl;
// 	cout << sizeof(Stack) << endl;

// 	return 0;
// }

// // 空类 -> 1
// // 这一个字节，不存储有效数据，标识对象被定义出来
// class A3
// {};

// // 1byte
// class A2 {
// public:
// 	void f2() {}
// };

// int main()
// {
// 	// 类 -> 对象   1->多
// 	// 对象的实例化
// 	// 对象的占用的大小，只考虑成员变量

// 	cout << sizeof(A3) << endl;
// 	A3 aa1;
// 	A3 aa2;

// 	return 0;
// }

// class A4
// {
// //private:
// 	char _ch;
// 	int _i;
// };

// int main()
// {
// 	cout << sizeof(A4) << endl;

// 	return 0;
// }



//class Date
//{
//public:
//	void Init(int year, int month, int day)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//
//	//void Print(Date* const this)
//	void Print()
//	{
//		// this = nullptr;
//		cout << this->_year << "-" << this->_month << "-" << this->_day << endl;
//		cout << _year << "-" << _month << "-" << _day << endl;
//	}
//
//private:
//	int _year; // 年
//	int _month; // 月
//	int _day; // 日
//};
//
//int main()
//{
//	Date d1;
//	Date d2;
//	d1.Init(2024, 4, 2);
//	d2.Init(2024, 4, 3);
//
//	//d1.Print(&d1);
//	d1.Print();
//
//	//d2.Print(&d2);
//	d2.Print();
//
//	return 0;
//}

//class A
//{
//public:
//	void Print()
//	{
//		cout << this << endl;
//		cout << "Print()" << endl;
//		cout << this->_a << endl;
//
//	}
//private:
//	int _a;
//};
//
//int main()
//{
//	A aa;
//	//A* p = &aa;
//	A* p = nullptr;
//	p->Print();
//
//	return 0;
//}






//class Date
//{
//public:
//	// 他们俩构成函数重载，但是无参调用时会存在歧义
//	/*Date()
//	{
//		_year = 1;
//		_month = 1;
//		_day = 1;
//	}*/
//
//	// 一般情况，建议每个类，都可以写一个全缺省的构造（好用）
//	Date(int year = 1, int month = 1, int day = 1)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//
//	//void Init(int year, int month, int day)
//	//{
//	//	_year = year;
//	//	_month = month;
//	//	_day = day;
//	//}
//
//	void Print()
//	{
//		cout << _year << "-" << _month << "-" << _day << endl;
//	}
//
//private:
//	int _year; // 年
//	int _month; // 月
//	int _day; // 日
//};
//
////Date func();
////Date func(int x, int y, int z);
//
//int main()
//{
//	//Date d1();  无法跟函数声明区分开
//	Date d1;
//	d1.Print();
//
//	Date d2(2024, 4, 2);
//	d2.Print();
//
//	Date d3(2024);
//	d3.Print();
//
//	Date d4(2024, 4);
//	d4.Print();
//
//	return 0;
//}

//bool isValid(const char* s) {
//	Stack st;
//
//	while (*s)
//	{
//		if (*s == '[' || *s == '(' || *s == '{')
//		{
//			st.Push(*s);
//		}
//		else
//		{
//			// 右括号比左括号多，数量匹配问题
//			if (st.Empty())
//			{
//				return false;
//			}
//
//			// 栈里面取左括号
//			char top = st.Top();
//			st.Pop();
//
//			// 顺序不匹配
//			if ((*s == ']' && top != '[')
//				|| (*s == '}' && top != '{')
//				|| (*s == ')' && top != '('))
//			{
//				return false;
//			}
//		}
//
//		++s;
//	}
//
//	// 栈为空，返回真，说明数量都匹配  左括号多，右括号少匹配问题
//	return st.Empty();
//}
//
//int main()
//{
//	// 忘记调用Init，就使用
//	Date d1;
//	Date d2;
//
//	d1.Print();
//	d2.Print();
//
//	Stack st1;
//	st1.Push(1);
//	st1.Push(2);
//	st1.Push(3);
//
//	cout << isValid("[]") << endl;
//}



class A
{
public:
	//A(int a)
	A()
	{
		_a = 0;
		cout << "A()" << endl;
	}

private:
	int _a;
};


class Date
{
public:
	// 我们没写，有没有构造函数？有->编译器自动生成
	// 内置类型/基本类型 int/char/double.../指针 
	// 自定义类型       class/struct...
	// 编译器自动生成构造函数，对于内置类型成员变量，没有规定要不要做处理！(有些编译器会处理)
	//                       对于自定义类型成员变量才会调用他的无参构造
	// 自动生成的构造函数意义何在？
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}

private:
	int _year; // 年
	int _month; // 月
	int _day; // 日

	A _aa;
};

// 自动生成的构造函数意义何在？
// 两个栈实现一个队列
class MyQueue
{
private:
	Stack _pushst;
	Stack _popst;
};

int main()
{
	Date d1;
	d1.Print();

	/*Date d2(2024, 4, 2);
	d2.Print();*/

	MyQueue q;

	return 0;
}